{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-17T02:48:05.985015Z",
     "start_time": "2025-02-17T02:48:02.247144Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=False)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-17T02:56:28.496526Z",
     "start_time": "2025-02-17T02:56:28.458123Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2 一段英文文本如何变为数值类型"
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-17T03:58:43.716327Z",
     "start_time": "2025-02-17T03:58:43.653823Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-10T03:20:52.117629200Z",
     "start_time": "2024-07-10T03:20:52.105434800Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-17T04:05:48.233632Z",
     "start_time": "2025-02-17T04:05:47.112826Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Dumping model to file cache C:\\Users\\wang\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.995 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-10T03:33:09.211241500Z",
     "start_time": "2024-07-10T03:33:09.185757100Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-17T07:32:47.912607Z",
     "start_time": "2025-02-17T07:32:47.818863Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "(1-60)/30"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-17T07:32:52.046226Z",
     "start_time": "2025-02-17T07:32:51.977603Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-11T02:17:48.991725400Z",
     "start_time": "2024-07-11T02:17:48.966657400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "numpy.ndarray"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:18:33.954581900Z",
     "start_time": "2024-07-11T02:18:33.940452300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244,  0.98058068],\n",
    " [-0.26726124,  0.33968311,  0.39223227],\n",
    " [ 1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-17T07:43:43.479284Z",
     "start_time": "2025-02-17T07:43:43.434346Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "1.5555556666666668"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:27:52.239803100Z",
     "start_time": "2024-04-16T03:27:52.199808400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.068779614944516"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:28:08.971612200Z",
     "start_time": "2024-04-16T03:28:08.956621100Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种 mean,median,most_frequent\n",
    "    # strategy:mean,median,most_frequent,constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:07.050388100Z",
     "start_time": "2024-07-11T02:23:07.037320600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "3.6666666666666665"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:22:34.367453500Z",
     "start_time": "2024-07-11T02:22:34.322497700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "nan"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan+10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:44.133095700Z",
     "start_time": "2024-07-11T02:23:44.114673600Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-11T02:50:10.534928700Z",
     "start_time": "2024-07-11T02:50:10.516186800Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-17T08:20:59.875968Z",
     "start_time": "2025-02-17T08:20:59.825111Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "22/29.333333333333336"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-17T08:20:39.493504Z",
     "start_time": "2025-02-17T08:20:36.788854Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
